-- *****************************************************************
-- CISCO-L4L7MODULE-REDUNDANCY-MIB.my:
-- Redundancy MIB for Service Modules using
-- a Cisco Proprietary Protocol.
--
-- Mar 2008, Umayal Ramanathan
--
-- Copyright (c) 2008 by cisco Systems Inc.
-- All rights reserved.
-- *****************************************************************CISCO-L4L7MODULE-REDUNDANCY-MIB DEFINITIONS::=BEGIN
IMPORTSMODULE-IDENTITY,NOTIFICATION-TYPE,OBJECT-TYPE,Unsigned32,Counter64FROM SNMPv2-SMI
MODULE-COMPLIANCE,OBJECT-GROUP,NOTIFICATION-GROUPFROM SNMPv2-CONF
InetAddressType,InetAddressFROM INET-ADDRESS-MIB
TEXTUAL-CONVENTION,TimeStamp,TruthValue,RowStatus,StorageTypeFROM SNMPv2-TC
InterfaceIndex,InterfaceIndexOrZeroFROM IF-MIB
entPhysicalIndex
FROM ENTITY-MIB
ciscoMgmt
FROM CISCO-SMI;ciscoL4L7moduleRedundancyMIB MODULE-IDENTITYLAST-UPDATED"200804040000Z"ORGANIZATION"Cisco Systems, Inc."CONTACT-INFO"Cisco Systems
Customer Service
Postal: 170 W. Tasman Drive
San Jose, CA 95134
USA
Tel: +1 800 553-NETS
E-mail: cs-l4l7security@cisco.com"DESCRIPTION"The L4-7 SLB devices are used
for scaling websites, building web
enabled applications, and migrating
to web services. The following services
( but not limited to ) can be provided by
L4-7 slb devices:
SLB ( Server Load Balancing )
FW ( Firewall )
SSL ( Secure Socket Layer )
IDS ( Intrusion Detection System ) .
This MIB provides the tables/objects that
support redundancy configuration and
redundancy statistics.
The redundancy model supported by this MIB
allows two or more SLB devices to be
configured with one or more redundancy
group. Each redundancy group is identified by
a unique group ID. Two or more devices are
redundant to each other if they use the
same redundancy Group ID.
Acronyms and terms:
HB Heart Beat
FT Fault Tolerant
HA High Availability
VLAN Virtual Local Area Network
LB Load Balance"REVISION"200804040000Z"DESCRIPTION"Added a new state 'warmCompatible' to
clrPeerSoftwareCompatibilty
Added a new state 'standbyWarm' to ciscoL4L7RedState."REVISION"200803130000Z"DESCRIPTION"Initial version of this MIB module."::={ ciscoMgmt 650}ciscoLmRedundancyMIBNotifs OBJECTIDENTIFIER::={ ciscoL4L7moduleRedundancyMIB 0}ciscoLmRedundancyMIBObjects OBJECTIDENTIFIER::={ ciscoL4L7moduleRedundancyMIB 1}ciscoLmRedundancyMIBConformance OBJECTIDENTIFIER::={ ciscoL4L7moduleRedundancyMIB 2}clrConfig OBJECTIDENTIFIER::={ ciscoLmRedundancyMIBObjects 1}clrStats OBJECTIDENTIFIER::={ ciscoLmRedundancyMIBObjects 2}clrNotifObjects OBJECTIDENTIFIER::={ ciscoLmRedundancyMIBObjects 3}CiscoL4L7RedState ::=TEXTUAL-CONVENTIONSTATUScurrentDESCRIPTION"The redundancy state of the device
in redundancy configuration.
'other' : other than values defined below.
'nonRedundant' : redundancy has not been configured.
'initializing' : establish necessary system services
'negotiation' : peer unit discovery and negotiation
'active' : device is in active state. It is
servicing the requests.
'standbyCold' : standby will take over if
synchronization is failed using
bulk synch mechanism.
'standbyConfig' : The active device receives a
notification to send a snapshot of its
running-config to the local standby
device.
'standbyBulk' : The active device receives a
notification to send a snapshot of the
current state information for all
applications to the standby device.
'standbyHot' : Incremental data synchronization
continues. This unit is ready and is
able to instantly take over activity.
'standbyWarm' : When the peer software compatibility
is warmCompatible ( a state in
clrPeerSoftwareCompatibility ) , the
redundant groups on standby goes to
standbyWarm instead of standbyHot.
Whether the bulk config sync
fails/passes the transition to
standbyBulk is always made
and eventually the standby device goes
to standbyWarm. The standbyWarm state is
similar to standbyHot state ( config
mode will be locked, state replication/
config sync are continued ) , but when
config-sync failed, there is no move to
standbyCold state."SYNTAXINTEGER{other(1),nonRedundant(2),initializing(3),negotiation(4),active(5),standbyCold(6),standbyConfig(7),standbyBulk(8),standbyHot(9),standbyWarm(10)}clrPeerConfigTable OBJECT-TYPESYNTAXSEQUENCEOF ClrPeerConfigEntry
MAX-ACCESSnot-accessibleSTATUScurrent
DESCRIPTION"This table is for configuring peer groups that are
part of redundancy configuration. The peer configuration
specifies the information used for exchanging High
Availability information related to redundancy groups."::={ clrConfig 1}clrPeerConfigEntry OBJECT-TYPESYNTAX ClrPeerConfigEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"An entry in clrPeerConfigTable. Each entry contains information
about peer interface, query interface, heart beat
count and heart beat time."INDEX{
entPhysicalIndex,
clrPeerId
}::={ clrPeerConfigTable 1}
ClrPeerConfigEntry ::=SEQUENCE{
clrPeerId Unsigned32,
clrPeerInterface InterfaceIndex,
clrPeerBackupInterface InterfaceIndexOrZero,
clrPeerHeartBeatTime Unsigned32,
clrPeerHeartBeatCount Unsigned32,
clrPeerStorageType StorageType,
clrPeerRowStatus RowStatus}clrPeerId OBJECT-TYPESYNTAXUnsigned32(1..65535)MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"This object identifies unique id for the peer.
The peer is used in redundancy configuration."::={ clrPeerConfigEntry 1}clrPeerInterface OBJECT-TYPESYNTAXInterfaceIndexMAX-ACCESSread-createSTATUScurrentDESCRIPTION"This object specifies the interface used by the
peers to exchange High Availability ( HA ) protocol
information."::={ clrPeerConfigEntry 2}clrPeerBackupInterface OBJECT-TYPESYNTAXInterfaceIndexOrZeroMAX-ACCESSread-createSTATUScurrentDESCRIPTION
"This object specifies the backup interface used by the
peer. The backup interface is used in case the heart beat
message is not received. This interface is used to
send the heart beat message. If the message sent is not
successful, then it is assumed peer is down and switchover
will be initiated. If the message sent is successful
on this interface, the peer transitions to standbyCold
and continue to monitor peer."DEFVAL{0}::={ clrPeerConfigEntry 3}clrPeerHeartBeatTime OBJECT-TYPESYNTAXUnsigned32UNITS"milliseconds"MAX-ACCESSread-createSTATUScurrentDESCRIPTION"The time interval between heartbeat/keep-alive
messages exchanged between the peers."DEFVAL{1}::={ clrPeerConfigEntry 4}clrPeerHeartBeatCount OBJECT-TYPESYNTAXUnsigned32MAX-ACCESSread-createSTATUScurrentDESCRIPTION
"This object is used in conjunction with
'clrPeerHeartBeatTime' to switch over the active
redundancy unit or not. Switch over occurs if
heartbeats are not received from the peer
during a specific time period, which
is equal to ( clrPeerHeartBeatTime *
clrPeerHeartBeatCount ) ."DEFVAL{1}::={ clrPeerConfigEntry 5}clrPeerStorageType OBJECT-TYPESYNTAXStorageTypeMAX-ACCESSread-createSTATUScurrentDESCRIPTION"The storage type for this conceptual row."DEFVAL{ nonVolatile }::={ clrPeerConfigEntry 6}clrPeerRowStatus OBJECT-TYPESYNTAXRowStatusMAX-ACCESSread-createSTATUScurrentDESCRIPTION"This object is used for adding/deleting
entries from the table.
An entry MUST NOT exist in the active state unless all
objects in the entry have an appropriate value, as described
in the description clause for each writable object.
This object may be modified if the associated
instance of this object is equal to active(1),
notInService(2), or notReady(3). All other writable objects
may be modified if the associated instance of this object is
equal to notInService(2) or notReady(3)."::={ clrPeerConfigEntry 7}clrPeerInfoTable OBJECT-TYPESYNTAXSEQUENCEOF ClrPeerInfoEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"This table contains information of the redundancy peer."::={ clrConfig 2}clrPeerInfoEntry OBJECT-TYPESYNTAX ClrPeerInfoEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"An entry in peer information table. An entry will get created
whenever an entry is created in clrPeerConfigTable. Each entry
contains information such as peer state, peer ip address,
software and license compatibility. The entPhysicalIndex
specifies an entry in entPhysicalTable with entPhysicalClass
representing the value of 'module'."INDEX{
entPhysicalIndex,
clrPeerId
}::={ clrPeerInfoTable 1}
ClrPeerInfoEntry ::=SEQUENCE{
clrPeerOperStatus INTEGER,
clrPeerIpAddressType InetAddressType,
clrPeerIpAddress InetAddress,
clrPeerSoftwareCompatibilty INTEGER,
clrPeerLicenseCompatibility INTEGER,
clrPeerRedGroups Unsigned32}clrPeerOperStatus OBJECT-TYPESYNTAXINTEGER{init(1),localIPaddr(2),peerIPAddr(3),startHB(4),tcpSetup(5),srgCheck(6),licCheck(7),
compatible(8),peerInterfaceDown(9),down(10),error(11)}MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object identifies the current status of the peer. The
possible values are
init(1) : The initial state of the peer.
localIPaddr(2) : The local device IP address is missing.
Waiting for the local IP address
to be configured.
peerIPAddr(3) : The peer IP address is missing. Waiting
for the peer IP address to be configured.
startHB(4) : The peer configuration is complete.
Starting the heartbeat to see if there
is a peer device.
tcpSetUp(5) : The heartbeat has detected the presence
of the peer device. Redundancy is in
the process of establishing a TCP
connection to the peer.
srgCheck(6) : Checking for software version
compatibility with the peer device.
licCheck(7) : Checking for license compatibility with
the peer device.
compatible(8) : Version and license checks indicate that
the peer is compatible for redundancy.
peerInterfaceDown(9): The peer interface ( used for transmitting
and receiving HB messages ) is down,
but, through the query interface,
the local device has determined that
the peer is still alive.
down(10) : The peer device is down.
error(11) : Indicates that an error has occurred
with the peer. Possible errors are:
version mismatch, license mismatch,
or failure to establish a TCP connection
to the peer. A syslog message appears
with more detailed information."::={ clrPeerInfoEntry 1}clrPeerIpAddressType OBJECT-TYPESYNTAXInetAddressTypeMAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The type of internet address by which the
peer is reachable."::={ clrPeerInfoEntry 2}clrPeerIpAddress OBJECT-TYPESYNTAXInetAddressMAX-ACCESSread-only
STATUScurrentDESCRIPTION"This Internet address for the redundant peer.
The type of this address is determined by the
value of the clrPeerIpAddressType object."::={ clrPeerInfoEntry 3}clrPeerSoftwareCompatibilty OBJECT-TYPESYNTAXINTEGER{init(1),compatible(2),inCompatible(3),warmCompatible(4)}MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"Indicates whether the software version of the local device
and the software version of the peer are compatible. The
possible values are:
init(1) : initialization state.
compatible(2) : software version of the local and peer
device are compatible.
inCompatible(3) : software version of the local and peer
device are not compatible.
warmCompatible(4) : When the software version check of the
local and the peer device returns
'supersedes' or 'superseded_by'
then the clrPeerSoftwarecompatibility of
the peer device is set to 'warmCompatible'."::={ clrPeerInfoEntry 4}clrPeerLicenseCompatibility OBJECT-TYPESYNTAXINTEGER{init(1),compatible(2),inCompatible(3)}MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"Indicates whether the license of the local device and the
license of the peer device are compatible. The possible
values are:
init(1) : initialization state.
compatible(2) : license version of the local and peer
device are compatible.
inCompatible(3) : license version of the local and peer
device are not compatible."::={ clrPeerInfoEntry 5}clrPeerRedGroups OBJECT-TYPESYNTAXUnsigned32
MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object refers to the number of redundancy groups the peer
is associated with."DEFVAL{0}::={ clrPeerInfoEntry 6}clrRedundancyConfigTable OBJECT-TYPESYNTAXSEQUENCEOF ClrRedundancyConfigEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"This table is used for configuring
redundancy groups. The redundancy group
is configured by specifying the same
value of 'clrRedGroupId' in multiple devices."::={ clrConfig 3}clrRedundancyConfigEntry OBJECT-TYPESYNTAX ClrRedundancyConfigEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"An entry in redundancy table.
Each entry contains information such
as priority, preempt. Preemption
ensures that the group member with high priority
always becomes active. The entPhysicalIndex
specifies the entry in entPhysicalTable with
entPhysicalClass representing the value of 'module'."INDEX{
entPhysicalIndex,
clrRedGroupId
}::={ clrRedundancyConfigTable 1}
ClrRedundancyConfigEntry ::=SEQUENCE{
clrRedGroupId Unsigned32,
clrRedPeerId Unsigned32,
clrRedPriority Unsigned32,
clrRedPreempt TruthValue,
clrRedFailOverTime Unsigned32,
clrRedState CiscoL4L7RedState,
clrRedStateChangeTime TimeStamp,
clrRedContext OCTETSTRING,
clrRedStorageType StorageType,
clrRedRowStatus RowStatus}clrRedGroupId OBJECT-TYPESYNTAXUnsigned32(1..4096)MAX-ACCESSnot-accessibleSTATUScurrent
DESCRIPTION"This object specifies the redundancy group
identifier. This is the unique id of the
redundancy group."::={ clrRedundancyConfigEntry 1}clrRedPeerId OBJECT-TYPESYNTAXUnsigned32(1..65535)MAX-ACCESSread-createSTATUScurrentDESCRIPTION"The peer ID to which this group belongs.
There must be an entry in clrPeerConfigTable
with this value. This object cannot be modified
if the associated clrRedRowStatus object is equal
to 'active'."::={ clrRedundancyConfigEntry 2}clrRedPriority OBJECT-TYPESYNTAXUnsigned32(1..255)MAX-ACCESSread-createSTATUScurrentDESCRIPTION"The priority value of the redundancy group.
This value is used in selecting the active
and standby peer.
The devices that belong to the same
redundancy group must be configured with a different
priority. The redundancy group with a highest
priority will become active unit during
negotiation phase of the redundancy.
If two (or more) devices in a group have
the same priority, the one with the highest IP address
of the interface is the active device.
If a redundancy group with high priority
value is online after its peer has become
active, then the group with high priority
will become standby. This behavior can be
changed by setting clrRedPreempt object to
'true'."DEFVAL{10}::={ clrRedundancyConfigEntry 3}clrRedPreempt OBJECT-TYPESYNTAXTruthValueMAX-ACCESSread-createSTATUScurrentDESCRIPTION"This specifies whether a high priority
redundancy device can become active irrespective
of the time at which it is online.
The value 'true' specifies that the redundancy
group with higher priority will always become active.
The value 'false' specifies that the redundacy
device which becomes active will remain active
even if another redundancy device comes online
with higher priority."DEFVAL{ true }::={ clrRedundancyConfigEntry 4}
clrRedFailOverTime OBJECT-TYPESYNTAXUnsigned32MAX-ACCESSread-createSTATUScurrentDESCRIPTION"The time to wait before standby redundancy
group become active. This represents the amount
of time a module need to wait after the last
keep-alive message is received before assuming
the peer is not operating."DEFVAL{3}::={ clrRedundancyConfigEntry 5}clrRedState OBJECT-TYPESYNTAX CiscoL4L7RedState
MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The current redundancy state."::={ clrRedundancyConfigEntry 6}clrRedStateChangeTime OBJECT-TYPESYNTAXTimeStampMAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The time of the last change in the current
redundancy state."::={ clrRedundancyConfigEntry 7}clrRedContext OBJECT-TYPESYNTAXOCTETSTRINGMAX-ACCESSread-createSTATUScurrentDESCRIPTION"This object refers to the context name to which the redundant
group is associated with. The context refers to the logical
partitioning within a device. The context can be identified
by a unique name in a device."::={ clrRedundancyConfigEntry 8}clrRedStorageType OBJECT-TYPESYNTAXStorageTypeMAX-ACCESSread-createSTATUScurrentDESCRIPTION"The storage type for this conceptual row."DEFVAL{ nonVolatile }::={ clrRedundancyConfigEntry 9}clrRedRowStatus OBJECT-TYPESYNTAXRowStatusMAX-ACCESSread-createSTATUScurrent
DESCRIPTION"This object is used for adding/deleting
entries from the table.
An entry MUST NOT exist in the active state unless all
objects in the entry have an appropriate value, as described
in the description clause for each writable object.
This object may be modified if the associated
instance of this object is equal to active(1),
notInService(2), or notReady(3). All other writable objects
may be modified if the associated instance of this object is
equal to notInService(2) or notReady(3)."::={ clrRedundancyConfigEntry 10}clrRedundancyInfoTable OBJECT-TYPESYNTAXSEQUENCEOF ClrRedundancyInfoEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"This table contains information on the
devices that are part of redundancy group."::={ clrConfig 4}clrRedundancyInfoEntry OBJECT-TYPESYNTAX ClrRedundancyInfoEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"An entry in redundancy information table.
An entry will get created whenever an
entry is created in clrRedundancyConfigTable.
Each entry contains information such
as priority, state and last time
when the redundancy state got changed.
The entPhysicalIndex specifies an entry in
entPhysicalTable with entPhysicalClass representing
the value of 'module'."INDEX{
entPhysicalIndex,
clrRedGroupId
}::={ clrRedundancyInfoTable 1}
ClrRedundancyInfoEntry ::=SEQUENCE{
clrRedundancyPriority Unsigned32,
clrRedundancyState CiscoL4L7RedState,
clrRedundancyStateChangeTime TimeStamp,
clrRedundancyIpAddressType InetAddressType,
clrRedundancyIpAddress InetAddress}clrRedundancyPriority OBJECT-TYPESYNTAXUnsigned32(1..255)MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The priority value of this redundancy
entry. This value is same as the
value configured in 'clrRedPriority'
for a redundancy group."::={ clrRedundancyInfoEntry 1}clrRedundancyState OBJECT-TYPESYNTAX CiscoL4L7RedState
MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The current redundancy state."::={ clrRedundancyInfoEntry 2}clrRedundancyStateChangeTime OBJECT-TYPESYNTAXTimeStampMAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The time of the last change in the current
redundancy state."::={ clrRedundancyInfoEntry 3}clrRedundancyIpAddressType OBJECT-TYPESYNTAXInetAddressTypeMAX-ACCESSread-onlySTATUScurrentDESCRIPTION"The type of internet address by which
this redundant device reachable."::={ clrRedundancyInfoEntry 4}clrRedundancyIpAddress OBJECT-TYPESYNTAXInetAddressMAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object identifies the Internet address by which
this redundant device is reachable. The type of this
address is determined by the value of the
clrRedundancyIpAddressType object."::={ clrRedundancyInfoEntry 5}clrLBStatsTable OBJECT-TYPESYNTAXSEQUENCEOF ClrLBStatsEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"This table contains the load balance statistics
related to a redundancy group."::={ clrStats 1}clrLBStatsEntry OBJECT-TYPESYNTAX ClrLBStatsEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"Each entry represents the load balance statistics
applicable for a redundancy group. The entPhysicalIndex
specifies the entry in entPhysicalTable.
The entries will get created in this table
by way of adding entries in clrRedundancyConfigTable.
The entries will be deleted from this table
by way of removing entries in clrRedundancyConfigTable."INDEX{
entPhysicalIndex,
clrRedGroupId
}::={ clrLBStatsTable 1}
ClrLBStatsEntry ::=SEQUENCE{
clrLBStatsSharedStickyEntries Counter64,
clrLBStatsSentPackets Counter64,
clrLBStatsSendFailures Counter64,
clrLBStatsDroppedEntries Counter64,
clrLBStatsReceivedPackets Counter64,
clrLBStatsReceiveFailures Counter64}clrLBStatsSharedStickyEntries OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object indicates the number of sticky entries that the
local device sent to the peer. Sticky entries is a LB
configuration which allows multiple connections from the same
client to be sent to the same server. Stickiness can be
configured based on source IP address, HTTP cookies, SSL session
ID ( for SSL traffic only ) , etc."::={ clrLBStatsEntry 1}clrLBStatsSentPackets OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object contains the number of valid packets that the local
device sent to the peer."::={ clrLBStatsEntry 2}clrLBStatsSendFailures OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object contains the number of packets that the local
device attempted to send to the peer, but failed."::={ clrLBStatsEntry 3}clrLBStatsDroppedEntries OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object contains the number of sticky entries that the peer
sent to the local device, but the local device discarded them."::={ clrLBStatsEntry 4}clrLBStatsReceivedPackets OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object contains the number of valid packets that the local
device received from the peer."::={ clrLBStatsEntry 5}clrLBStatsReceiveFailures OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object contains the number of packets that the peer sent
to the local device, but the local device failed to receive
them."::={ clrLBStatsEntry 6}clrHAStatsTable OBJECT-TYPESYNTAXSEQUENCEOF ClrHAStatsEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"This table contains the statistics related to
a redundant peer."::={ clrStats 2}clrHAStatsEntry OBJECT-TYPESYNTAX ClrHAStatsEntry
MAX-ACCESSnot-accessibleSTATUScurrentDESCRIPTION"Each entry represents the statistics
applicable for a redundant peer.
The entPhysicalIndex specifies the
entry in entPhysicalTable .
The entries will get created in this table
by way of adding entries in clrPeerConfigTable.
The entries will be deleted from this table
by way of removing entries in clrPeerConfigTable."INDEX{
entPhysicalIndex,
clrPeerId
}::={ clrHAStatsTable 1}
ClrHAStatsEntry ::=SEQUENCE{
clrHAStatsTxHeartBeatMsgs Counter64,
clrHAStatsRxHeartBeatMsgs Counter64,
clrHAStatsMissedHeartBeatMsgs Counter64,
clrHAStatsRxUniDirectionalHeartBeatMsgs Counter64,
clrHAStatsHeartBeatTimeoutMismatches Counter64,
clrHAStatsPeerUpEvents Counter64,
clrHAStatsPeerDownEvents Counter64}clrHAStatsTxHeartBeatMsgs OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object refers to the number of heart beat messages sent
to the peer."::={ clrHAStatsEntry 1}clrHAStatsRxHeartBeatMsgs OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object refers to the number of heart beat messages
received from the peer."::={ clrHAStatsEntry 2}clrHAStatsMissedHeartBeatMsgs OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object refers to the number of missed heart
beat messages."::={ clrHAStatsEntry 3}
clrHAStatsRxUniDirectionalHeartBeatMsgs OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object indicates that the heartbeat messages from a peer
is unidirectional. That is, the peer cannot receive ( only send
) heartbeats."::={ clrHAStatsEntry 4}clrHAStatsHeartBeatTimeoutMismatches OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"Each HB packet contains the configured interval in the packet.
When a peer receives a HB packet, it checks to see if the
interval in the HB packet matches the interval configured
locally. This object indicates the number of HB that the local
device received from the remote peer with a mismatched HB
interval."::={ clrHAStatsEntry 5}clrHAStatsPeerUpEvents OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrent
DESCRIPTION"This object contains the number of peer up messages that the
local device sent to the remote peer."::={ clrHAStatsEntry 6}clrHAStatsPeerDownEvents OBJECT-TYPESYNTAXCounter64MAX-ACCESSread-onlySTATUScurrentDESCRIPTION"This object contains the number of peer down messages that the
local device sent to the remote peer."::={ clrHAStatsEntry 7}clrStateChangeNotifEnabled OBJECT-TYPESYNTAXTruthValueMAX-ACCESSread-writeSTATUScurrentDESCRIPTION"This object controls the generation of
clrRedundancyStateChange notification.
'true' : Indicates that clrRedundancyStateChange
notification is to be generated when the state
changes. That is, notification generation
is enabled.
'false' : Indicates that clrRedundancyStateChange
notification generation is disabled."DEFVAL{ false }::={ clrNotifObjects 1}clrRedundancyStateChange NOTIFICATION-TYPEOBJECTS{
clrRedState,
clrRedStateChangeTime,
clrRedPeerId
}STATUScurrentDESCRIPTION"The notification generated when the redundancy state
is changed."::={ ciscoLmRedundancyMIBNotifs 1}-- Conformance InformationciscoLmRedundancyMIBCompliances OBJECTIDENTIFIER::={ ciscoLmRedundancyMIBConformance 1}ciscoLmRedundancyMIBGroups OBJECTIDENTIFIER::={ ciscoLmRedundancyMIBConformance 2}-- ComplianceciscoLmRedundancyMIBCompliance MODULE-COMPLIANCESTATUScurrentDESCRIPTION"The compliance statement for entities which implement
the L4L7 Switch Redundancy."MODULE-- this module
MANDATORY-GROUPS{
clrPeerConfigGroup,
clrRedConfigGroup,
clrRedundancyStatsGroup
}::={ ciscoLmRedundancyMIBCompliances 1}-- Units of ConformanceclrPeerConfigGroup OBJECT-GROUPOBJECTS{
clrPeerInterface,
clrPeerBackupInterface,
clrPeerHeartBeatTime,
clrPeerHeartBeatCount,
clrPeerOperStatus,
clrPeerIpAddressType,
clrPeerIpAddress,
clrPeerStorageType,
clrPeerRowStatus,
clrPeerSoftwareCompatibilty,
clrPeerLicenseCompatibility,
clrPeerRedGroups
}STATUScurrentDESCRIPTION"This group contains the peer configuration objects."::={ ciscoLmRedundancyMIBGroups 1}clrRedConfigGroup OBJECT-GROUP
OBJECTS{
clrRedPeerId,
clrRedPriority,
clrRedPreempt,
clrRedFailOverTime,
clrRedState,
clrRedStateChangeTime,
clrRedStorageType,
clrRedRowStatus,
clrRedContext
}STATUScurrentDESCRIPTION"This group contains the redundancy configuration objects."::={ ciscoLmRedundancyMIBGroups 2}clrRedInfoGroup OBJECT-GROUPOBJECTS{
clrRedundancyPriority,
clrRedundancyState,
clrRedundancyStateChangeTime,
clrRedundancyIpAddressType,
clrRedundancyIpAddress
}STATUScurrentDESCRIPTION"This group contains the redundancy information objects."::={ ciscoLmRedundancyMIBGroups 3}
cslbxNotifControlGroup OBJECT-GROUPOBJECTS{ clrStateChangeNotifEnabled }STATUScurrentDESCRIPTION"The collection of objects to control the
notifications for state changed in a L4
redundancy configuration."::={ ciscoLmRedundancyMIBGroups 4}cslbxNotifGroup NOTIFICATION-GROUPNOTIFICATIONS{ clrRedundancyStateChange }STATUScurrentDESCRIPTION"This group contains the notifications related to
redundancy."::={ ciscoLmRedundancyMIBGroups 5}clrRedundancyStatsGroup OBJECT-GROUPOBJECTS{
clrHAStatsTxHeartBeatMsgs,
clrHAStatsRxHeartBeatMsgs,
clrHAStatsMissedHeartBeatMsgs,
clrHAStatsRxUniDirectionalHeartBeatMsgs,
clrHAStatsHeartBeatTimeoutMismatches,
clrHAStatsPeerUpEvents,
clrHAStatsPeerDownEvents,
clrLBStatsSharedStickyEntries,
clrLBStatsSentPackets,
clrLBStatsSendFailures,
clrLBStatsDroppedEntries,
clrLBStatsReceivedPackets,
clrLBStatsReceiveFailures
}STATUScurrentDESCRIPTION"This group contains objects related to redundant peer and
load balacing statistics."::={ ciscoLmRedundancyMIBGroups 6}END